from PyQt5.QtWidgets import *


class Form4(QWidget):
    def __init__(self, parent=None):
        super().__init__()

        # -*- coding: utf-8 -*-
        """
        Various methods of drawing scrolling plots.
        """

        import pyqtgraph as pg
        from pyqtgraph.Qt import QtCore, QtGui
        import numpy as np

        self.win = pg.GraphicsLayoutWidget(show=True)
        self.win.setWindowTitle('pyqtgraph example: Scrolling Plots')

        # 1) Simplest approach -- update data in the array such that plot appears to scroll
        #    In these examples, the array size is fixed.
        p1 = self.win.addPlot()
        p2 = self.win.addPlot()
        data1 = np.random.normal(size=300)
        curve1 = p1.plot(data1)
        curve2 = p2.plot(data1)
        ptr1 = 0

        def update1():
            global data1, ptr1
            data1[:-1] = data1[1:]  # shift data in the array one sample left
            # (see also: np.roll)
            data1[-1] = np.random.normal()
            curve1.setData(data1)

            ptr1 += 1
            curve2.setData(data1)
            curve2.setPos(ptr1, 0)

        # 2) Allow data to accumulate. In these examples, the array doubles in length
        #    whenever it is full.
        self.win.nextRow()
        p3 = self.win.addPlot()
        p4 = self.win.addPlot()
        # Use automatic downsampling and clipping to reduce the drawing load
        p3.setDownsampling(mode='peak')
        p4.setDownsampling(mode='peak')
        p3.setClipToView(True)
        p4.setClipToView(True)
        p3.setRange(xRange=[-100, 0])
        p3.setLimits(xMax=0)
        curve3 = p3.plot()
        curve4 = p4.plot()

        data3 = np.empty(100)
        ptr3 = 0

        def update2():
            global data3, ptr3
            data3[ptr3] = np.random.normal()
            ptr3 += 1
            if ptr3 >= data3.shape[0]:
                tmp = data3
                data3 = np.empty(data3.shape[0] * 2)
                data3[:tmp.shape[0]] = tmp
            curve3.setData(data3[:ptr3])
            curve3.setPos(-ptr3, 0)
            curve4.setData(data3[:ptr3])

        # 3) Plot in chunks, adding one new plot curve for every 100 samples
        chunkSize = 100
        # Remove chunks after we have 10
        maxChunks = 10
        startTime = pg.ptime.time()
        self.win.nextRow()
        p5 = self.win.addPlot(colspan=2)
        p5.setLabel('bottom', 'Time', 's')
        p5.setXRange(-10, 0)
        curves = []
        data5 = np.empty((chunkSize + 1, 2))
        ptr5 = 0

        def update3():
            global p5, data5, ptr5, curves
            now = pg.ptime.time()
            for c in curves:
                c.setPos(-(now - startTime), 0)

            i = ptr5 % chunkSize
            if i == 0:
                curve = p5.plot()
                curves.append(curve)
                last = data5[-1]
                data5 = np.empty((chunkSize + 1, 2))
                data5[0] = last
                while len(curves) > maxChunks:
                    c = curves.pop(0)
                    p5.removeItem(c)
            else:
                curve = curves[-1]
            data5[i + 1, 0] = now - startTime
            data5[i + 1, 1] = np.random.normal()
            curve.setData(x=data5[:i + 2, 0], y=data5[:i + 2, 1])
            ptr5 += 1

        # update all plots
        def update():
            update1()
            update2()
            update3()

        timer = pg.QtCore.QTimer()
        timer.timeout.connect(update)
        timer.start(50)

        btn_layout = QHBoxLayout()  # 添加按钮的水平布局
        btn_layout.addWidget(self.win)
        self.setLayout(btn_layout)
